class commonFuncation {

	isLogin() {
		if (!uni.getStorageSync('userInfo').token) {
			console.log('未登录操作')
			uni.navigateTo({
				url: '/pages/login'
			})
			return true
		} else {
			return false
		}
	}

	/**
	 * 获取权限
	 * @param {string} params.permission  对应权限的scope，例如 scope.bluetooth
	 * @param {String} params.permissionName  提示框显示的权限名称，例如 蓝牙
	 * @param {String} params.customPopup  将实现自定义的弹窗代替系统弹窗
	 * @param {Function} params.success  授权成功回调函数
	 * @param {Function} params.fail  授权失败回调函数
	 * @param {Function} params.cancel  取消继续授权回调函数
	 */
	getPermission(params) {

		const _permission = `scope.${params.permission}`
		const _tipsContent = `您拒绝了${params.permissionName}权限，将导致部分功能不能正常使用，去设置权限？`

		uni.getSetting({
			success(res) {
				// 判断是否有相关权限属性
				if (res.authSetting.hasOwnProperty(_permission)) {
					// 属性存在，且为false
					if (!res.authSetting[_permission]) {
						uni.showModal({
							title: '提示',
							content: _tipsContent,
							success: (res) => {
								if (res.confirm) {
									uni.openSetting()
								} else {
									if (params.cancel) {
										setTimeout(() => {
											params.cancel()
										}, 200)
									}
								}
							}
						})
					} else {
						params.success && params.success()
					}
				} else {
					// 属性不存在，需要授权
					uni.authorize({
						scope: _permission,
						success() {
							// 授权成功
							params.success && params.success()
						},
						fail() {
							uni.showModal({
								title: '提示',
								content: _tipsContent,
								success: (res) => {
									if (res.confirm) {
										uni.openSetting()
									} else {
										if (params.cancel) {
											setTimeout(() => {
												params.cancel()
											}, 200)
										}
									}
								}
							})
						}
					})
				}
			}
		})
	}

	/**
	 * 获取当前页面栈
	 */
	pages() {
		let pages = getCurrentPages();
		let prePage = pages[pages.length - 2];
		return prePage;
	}

	/**
	 * 页面跳转
	 * @param {Object} url 需要跳转的应用内非 tabBar 的页面的路径
	 */
	to(url) {
		uni.navigateTo({
			url,
			success: function(res) {

			},
			fail: function(e) {
				console.log('跳转失败', e)
			}
		})
	}

	/**
	 * 登录判断跳转
	 * @param {Object} url 需要跳转的应用内非 tabBar 的页面的路径
	 */
	auth(url) {
		if (uni.getStorageSync('token')) {
			this.to(url)
		} else {
			//未登录操作
			this.msg('请先登录')
		}
	}

	/**
	 * 页面返回
	 * @param {Object} num 返回页面数量
	 */
	back(num = 1) {
		console.log(num);
		uni.navigateBack({
			delta: num
		});
	}

	/**
	 * 拨打电话
	 * @param {JSON} number 电话号码
	 */
	phone(number) {
		uni.makePhoneCall({
			phoneNumber: number
		});
	}

	/**
	 *全局提示
	 * 
	 */
	msg(title, duration = 1500, mask = false, icon = 'none') {
		if (Boolean(title) === false) {
			return;
		}
		uni.showToast({
			title,
			duration,
			mask,
			icon
		});
		// uni.vibrateShort(); // 报错可以设置手机振动
	}

	/**
	 * 获取手机系统设置
	 */
	sys() {
		const sys = uni.getWindowInfo();
		const deviceInfo = uni.getDeviceInfo(); 
		const data = {
			top: sys.statusBarHeight,
			height: sys.statusBarHeight + uni.upx2px(90),
			screenHeight: sys.screenHeight,
			platform: deviceInfo.platform,
			model: deviceInfo.model,
			windowHeight: sys.windowHeight,
			windowBottom: sys.windowBottom,
			// deviceId: sys.deviceId,
			viewHeight: sys.screenHeight - sys.statusBarHeight - 44 - 44,
			safeAreaBottom: sys.safeAreaInsets.bottom ? sys.safeAreaInsets.bottom : 0
		};
		return data;
	}
	/**
	 * 数字格式化 
	 * @param {Object} number 数字
	 * @param {Object} type 类型 thousand:万,hundred:百
	 */
	toFormat(number, type) {
		//格式千位以上
		if (type == 'thousand') {
			if (number > 9999) {
				number = (number / 10000).toFixed(1) + 'w'
			} else if (number > 999) {
				number = (number / 1000).toFixed(1) + 'k'
			}
		}
		//格式百位
		if (type == 'hundred' && number > 99) {
			number = '99+';
		}
		return number;
	}
	/**
	 * 加法精度计算
	 * @param {Object} number 数字
	 */
	bcadd(a, b) {
		var c, d, e;
		try {
			c = a.toString().split(".")[1].length
		} catch (f) {
			c = 0
		}
		try {
			d = b.toString().split(".")[1].length
		} catch (f) {
			d = 0
		}
		return e = Math.pow(10, Math.max(c, d)), (this.bcmul(a, e) + this.bcmul(b, e)) / e
	}
	/**
	 * 减法精度计算
	 * 
	 * @param {Object} number 数字
	 */
	bcsub(a, b) {
		var c, d, e;
		try {
			c = a.toString().split(".")[1].length
		} catch (f) {
			c = 0
		}
		try {
			d = b.toString().split(".")[1].length
		} catch (f) {
			d = 0
		}
		return e = Math.pow(10, Math.max(c, d)), (this.bcmul(a, e) - this.bcmul(b, e)) / e
	}

	/**
	 * 乘法精度计算
	 * @param {Object} number 数字
	 */
	bcmul(a, b) {
		if (a === undefined || b === undefined) {
			return 0; // 或者 throw new Error('参数不能为undefined')
		}
		var c = 0,
			d = a.toString(),
			e = b.toString();
		try {
			c += d.split(".")[1].length
		} catch (f) {}
		try {
			c += e.split(".")[1].length
		} catch (f) {}
		return Number(d.replace(".", "")) * Number(e.replace(".", "")) / Math.pow(10, c)
	}

	/**
	 * 除法精度计算
	 * @param {Object} number 数字
	 */
	bcdiv(a, b) {
		var c, d, e = 0,
			f = 0;
		try {
			e = a.toString().split(".")[1].length
		} catch (g) {}
		try {
			f = b.toString().split(".")[1].length
		} catch (g) {}
		return c = Number(a.toString().replace(".", "")), d = Number(b.toString().replace(".", "")), this.bcmul(c /
			d, Math.pow(10, f - e))
	}

	/**
	 * 时间格式化
	 * @param String timestamp 时间戳
	 * @param String fmt 返回的时间格式
	 * yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合
	 */
	timeFormat(timestamp = null, fmt = 'yyyy-mm-dd') {
		// 其他更多是格式化有如下:
		// yyyy:mm:dd|yyyy:mm|yyyy年mm月dd日|yyyy年mm月dd日 hh时MM分等,可自定义组合
		timestamp = parseInt(timestamp);
		// 如果为null,则格式化当前时间
		if (!timestamp) timestamp = Number(new Date());
		// 判断用户输入的时间戳是秒还是毫秒,一般前端js获取的时间戳是毫秒(13位),后端传过来的为秒(10位)
		if (timestamp.toString().length == 10) timestamp *= 1000;
		let date = new Date(timestamp);
		let ret;
		let opt = {
			"y+": date.getFullYear().toString(), // 年
			"m+": (date.getMonth() + 1).toString(), // 月
			"d+": date.getDate().toString(), // 日
			"h+": date.getHours().toString(), // 时
			"M+": date.getMinutes().toString(), // 分
			"s+": date.getSeconds().toString() // 秒
			// 有其他格式化字符需求可以继续添加，必须转化成字符串
		};
		for (let k in opt) {
			ret = new RegExp("(" + k + ")").exec(fmt);
			if (ret) {
				fmt = fmt.replace(ret[1], (ret[1].length == 1) ? (opt[k]) : (opt[k].padStart(ret[1].length, "0")))
			};
		};
		return fmt;
	}

	/**
	 * IM时间友好 
	 * @param String timestamp 时间戳
	 * @param String | Boolean format 如果为时间格式字符串，超出一定时间范围，返回固定的时间格式；
	 * 如果为布尔值false，无论什么时间，都返回多久以前的格式
	 */
	timeToDate(timestamp = null) {
		if (timestamp == null) timestamp = Number(new Date());
		timestamp = parseInt(timestamp);
		// 判断用户输入的时间戳是秒还是毫秒,一般前端js获取的时间戳是毫秒(13位),后端传过来的为秒(10位)
		if (timestamp.toString().length == 10) timestamp *= 1000;
		var timer = (new Date()).getTime() - timestamp;
		timer = parseInt(timer / 1000);
		// 如果小于5分钟,则返回"刚刚",其他以此类推
		let tips = '';
		switch (true) {
			case timer < 300:
				tips = '刚刚';
				break;
			case timer >= 300 && timer < 3600:
				tips = parseInt(timer / 60) + '分钟前';
				break;
			case timer >= 3600 && timer < 86400:
				tips = parseInt(timer / 3600) + '小时前';
				break;
			case timer >= 86400 && timer < 2592000:
				tips = parseInt(timer / 86400) + '天前';
				break;
			default:
				// 如果format为false，则无论什么时间戳，都显示xx之前
				if (format === false) {
					if (timer >= 2592000 && timer < 365 * 86400) {
						tips = parseInt(timer / (86400 * 30)) + '个月前';
					} else {
						tips = parseInt(timer / (86400 * 365)) + '年前';
					}
				} else {
					tips = this.timeFormat(timestamp, format);
				}
		}
		return tips;
	}

	/**
	 *全局唯一标识符
	 * @param {Number} len uuid的长度
	 * @param {Boolean} firstU 将返回的首字母置为"u"
	 * @param {Nubmer} radix 生成uuid的基数(意味着返回的字符串都是这个基数),2-二进制,8-八进制,10-十进制,16-十六进制
	 */
	guid(len = 32, firstU = true, radix = null) {
		let chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
		let uuid = [];
		radix = radix || chars.length;

		if (len) {
			// 如果指定uuid长度,只是取随机的字符,0|x为位运算,能去掉x的小数位,返回整数位
			for (let i = 0; i < len; i++) uuid[i] = chars[0 | Math.random() * radix];
		} else {
			let r;
			// rfc4122标准要求返回的uuid中,某些位为固定的字符
			uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
			uuid[14] = '4';

			for (let i = 0; i < 36; i++) {
				if (!uuid[i]) {
					r = 0 | Math.random() * 16;
					uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
				}
			}
		}
		// 移除第一个字符,并用u替代,因为第一个字符为数值时,该guuid不能用作id或者class
		if (firstU) {
			uuid.shift();
			return 'u' + uuid.join('');
		} else {
			return uuid.join('');
		}
	}
}
export default new commonFuncation()